/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.dynaBlaster;

import com.dynaBlaster.DynaView.Area;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.View;

/**
 * TileView: a View-variant designed for handling arrays of "icons" or other
 * drawables.
 * 
 */
public class BoardView extends View {

	/**
	 * Parameters controlling the size of the tiles and their range within view.
	 * Width/Height are in pixels, and Drawables will be scaled to fit to these
	 * dimensions. X/Y Tile Counts are the number of tiles that will be drawn.
	 */

	public static int mTileSize;

	public static int mXTileCount;
	public static int mYTileCount;

	public static int mXOffset;
	public static int mYOffset;

	/**
	 * A hash that maps integer handles specified by the subclasser to the
	 * drawable that will be used for that reference
	 */
	protected Bitmap[] mTileArray;

	/**
	 * A two-dimensional array of integers in which the number represents the
	 * index of the tile that should be drawn at that locations
	 */
	protected int[][] mTileGrid;

	private final Paint mPaint = new Paint();

	public BoardView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);

		// TypedArray a = context.obtainStyledAttributes(attrs,
		// R.styleable.TileView);
		//
		// mTileSize = a.getInt(R.styleable.TileView_tileSize, 12);

		// TODO uzaleznic od wielkosci ekranu
		mTileSize = GameConfg.TILE_SIZE;

		// a.recycle();
	}

	public BoardView(Context context, AttributeSet attrs) {
		super(context, attrs);

		// TypedArray a = context.obtainStyledAttributes(attrs,
		// R.styleable.TileView);
		//
		// mTileSize = a.getInt(R.styleable.TileView_tileSize, 12);

		// TODO uzaleznic od wielkosci ekranu
		mTileSize = GameConfg.TILE_SIZE;

		// a.recycle();
	}

	@Override
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
		mXTileCount = (int) Math.floor(w / mTileSize);
		mYTileCount = (int) Math.floor(h / mTileSize);

		mXOffset = ((w - (mTileSize * mXTileCount)) / 2);
		mYOffset = ((h - (mTileSize * mYTileCount)) / 2);

		mTileGrid = new int[mXTileCount][mYTileCount];
		clearTiles();
	}

	/**
	 * Function to set the specified Drawable as the tile for a particular
	 * integer key.
	 * 
	 * @param key
	 * @param tile
	 */
	public void loadTile(int key, Drawable tile) {
		Bitmap bitmap = Bitmap.createBitmap(mTileSize, mTileSize, Bitmap.Config.ARGB_8888);
		Canvas canvas = new Canvas(bitmap);
		tile.setBounds(0, 0, mTileSize, mTileSize);
		tile.draw(canvas);

		mTileArray[key] = bitmap;
	}

	/**
	 * Resets all tiles to 0 (empty)
	 * 
	 */
	public void clearTiles() {
		for (int x = 0; x < mXTileCount; x++) {
			for (int y = 0; y < mYTileCount; y++) {
				setTile(0, x, y);
			}
		}
	}

	public void destroyWall(Point p) {
		mTileGrid[p.x][p.y] = Area.FREE.nr;

	}

	/**
	 * Used to indicate that a particular tile (set with loadTile and referenced
	 * by an integer) should be drawn at the given x/y coordinates during the
	 * next invalidate/draw cycle.
	 * 
	 * @param tileindex
	 * @param x
	 * @param y
	 */
	public void setTile(int tileindex, int x, int y) {
		mTileGrid[x][y] = tileindex;
	}

	public int getTile(Point p) {
		return mTileGrid[p.x][p.y];
	}

	@Override
	public void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		for (int x = 0; x < mXTileCount; x += 1) {
			for (int y = 0; y < mYTileCount; y += 1) {
				if (mTileGrid[x][y] > 0) {
					canvas.drawBitmap(mTileArray[mTileGrid[x][y]], mXOffset + x * mTileSize, mYOffset + y
							* mTileSize, mPaint);
				}
			}
		}

	}

	public static Point getAbsCoord(Point p) {
		return new Point(mXOffset + p.x * mTileSize + mTileSize / 2, mYOffset + p.y * mTileSize + mTileSize
				/ 2);
	}

	public static Point getBoardCoord(Point p) {
		int x = p.x - mXOffset;
		x = x / mTileSize;

		int y = p.y - mYOffset;
		y = y / mTileSize;

		return new Point(x, y);
	}

}
